Cream of the Crop 26/Cream of the Crop 26.iso/program/qlib205.zip/QLIB.ZIP/SRC/QLIB/STRING.ASM

Assembly Source File | 1997-07-09 | 14KB | 878 lines

include qlib.inc  ;setup
include dos.inc
include string.inc
include alloc.inc
include stdio.inc
include conio.inc
include key.inc

.data?
  ;used by sscanf & str2num
  _str2num_siz_ dd ?      ;this is how many letters str2num_* used from src
  tss db ?
  ts db 34 dup (?)
align 4
  h db ?  ;('a' or 'A') - 10
  tok dd ?     ;token pos (see strtok())
  tokend dd ?  ;token end

.code
_num2str_:
  ;eax = # to decode
  ;ebx = radix
  mov edi,offset ts+33
  mov byte ptr[edi],0
  dec edi
  mov ecx,32  ;the MAX
num2str_2:
  xor edx,edx
  div ebx
  .if dl<10
    add dl,'0'
  .else
    add dl,h
  .endif
  mov [edi],dl
  dec edi
  dec ecx
  jnz num2str_2
  .while edi!=offset ts
    mov bptr[edi],'0'
    dec edi
  .endw
  mov bptr[edi],'0'
  ret

copyit:
; esi => edi
;copies a string (and removes unneeded 0s)
  mov ebx,edi
  mov al,bptr[esi]
  .if (al=='-')
    movsb
    mov al,bptr[esi]
  .endif
  .if (al=='0')
    .while al=='0'
      lodsb
    .endw
    stosb
  .endif
  .if !al  ;the # is zero
    mov edi,ebx
    mov bptr[edi],'0'
    mov bptr[edi+1],0
    ret
  .endif
  .while al
    lodsb   ;can't use movsb : must get al loaded
    stosb
  .endw
  ret

num2str proc,a:dword,off:dword,rax:byte
  mov h,'a'-10
jumpin1::
  pushad
  xor ebx,ebx
  mov bl,rax
  .if (bl>36) || (bl<2)  ;tolerance
    mov ebx,off
    mov bptr[ebx],0
    popad
    mov eax,off
    ret
  .endif
  mov eax,a
  call _num2str_
  mov edi,off
  mov esi,offset ts
  call copyit

  popad
  mov eax,off
  ret
num2str endp

num2strc proc,a:dword,off:dword,rax:byte
  ;same as num2str except starts with capital letters when # > 9
  mov h,'A'-10
  jmp jumpin1
num2strc endp

;signed output (does not put in '+' symbol when pos)
num2strs proc,a:dword,off:dword,rax:byte
  mov h,'a'-10
jumpin2::
  pushad
  xor ebx,ebx
  mov bl,rax
  .if (bl>36) || (bl<2)  ;tolerance
    mov ebx,off
    mov bptr[ebx],0
    popad
    mov eax,off
    ret
  .endif
  mov eax,a
  .if eax & 80000000h
    neg eax
    mov tss,'-'
  .else
    mov tss,0
  .endif
@@:
  call _num2str_
  mov edi,off
  mov esi,offset ts
  .if tss
    dec esi
  .endif
  call copyit
  popad
  mov eax,off
  ret
num2strs endp

num2strsc proc,a:dword,off:dword,rax:byte
  ;same as num2str except starts with capital letters when # > 9
  mov h,'A'-10
  jmp jumpin2
num2strsc endp

strcpy proc,s1off:dword,s2off:dword
  ;s1=s2
  pushad
  mov edi,s1off
  mov esi,s2off
  callp strlen,esi
  mov ecx,eax
  inc ecx
  rep movsb
  popad
  mov eax,s1off
  ret
strcpy endp

strcat proc,s1off:dword,s2off:dword
  ;s1=s1+s2
  pushad
  mov edi,s1off
  mov esi,s2off
  callp strlen,esi
  mov ecx,eax
  inc ecx ;include NULL
  callp strlen,edi
  add edi,eax
  rep movsb
  popad
  mov eax,s1off
  ret
strcat endp

strlen proc uses edi ecx,off:dword
  mov edi,off
  or ecx,-1  ;faster than mov ecx,-1 (2 bytes shorter)
  xor al,al
  repnz scasb
  not ecx
  dec ecx
  mov eax,ecx
  ret
strlen endp

strcmp proc,p1:dword,p2:dword
  pushad
  mov esi,p1
  mov edi,p2
@@:
  cmpsb
  ja above
  jb below
  cmp byte ptr[esi-1],0
  jnz @b
  popad
  xor eax,eax
  ret
above:
  popad
  mov eax,1   ;p1 > p2
  ret
below:
  popad
  or eax,-1    ;p1 < p2
  ret
strcmp endp

;this is atol!!
str2num proc,s:dword
  local _neg:byte
  pushad
  mov esi,s
  dec esi
@@:
  inc esi
  cmp bptr[esi],0
  jz bad
  cmp bptr[esi],'+'
  jz start
  cmp bptr[esi],'-'
  jz start
  cmp bptr[esi],'0'
  jb @b
  cmp bptr[esi],'9'
  ja @b
  jmp start
bad:
  popad
  mov _str2num_siz_,0
  xor eax,eax
  ret
start:
  mov _neg,0
  .if bptr[esi]=='-'
    inc _neg
    inc esi
  .elseif bptr[esi]=='+'
    inc esi ;ignore it
  .endif
  xor ebx,ebx
  mov edi,esi
  dec edi
@@:
  cmp bptr[esi],0
  jz cont
  cmp bptr[esi],'0'
  jb cont
  cmp bptr[esi],'9'
  ja cont
  inc esi
  inc bl
  jmp @b
cont:
  cmp bl,10
  ja bad ;to many digits!
  cmp bl,0
  jz bad ;no digits (could happen eg: + w/o any #s )
  dec esi
  mov _str2num_siz_,esi
  mov eax,s
  sub _str2num_siz_,eax
  inc _str2num_siz_  ;total size!
  ;go till esi=edi
  mov ebx,1
  xor ecx,ecx  ;total
@@:
  xor eax,eax
  mov al,[esi]
  sub al,'0'
  mul ebx
  add ecx,eax
  mov eax,10
  mul ebx
  mov ebx,eax
  dec esi
  cmp esi,edi
  jnz @b
done:
  mov eax,ecx
  .if _neg
    neg eax
  .endif
  mov [esp+7*4],eax
  popad
  ret
str2num endp

;this is atoh???  Hex version
str2numx proc,s:dword
  pushad
  mov esi,s
@@:
  mov ax,[esi]
  cmp al,0
  jz bad
  .if ax=='x0' || ax=='X0'   ;these are 0x and 0X
    add esi,2
    jmp @b
  .endif
  .if (al>='0') && (al<='9')
    jmp start
  .endif
  .if (al>='A') && (al<='F')
    jmp start
  .endif
  .if (al>='a') && (al<='f')
    jmp start
  .endif
  inc esi
  jmp @b
bad:
  popad
  mov _str2num_siz_,0
  xor eax,eax
  ret
start:
  xor bl,bl
  mov edi,esi
  dec edi
@@:
  cmp bl,8
  ja bad     ;to many digits!
  mov al,[esi]
  cmp bptr[esi],0
  jz cont
  .if (al>='A') && (al<='F')
    inc bl
    inc esi
    jmp @b
  .endif
  .if (al>='a') && (al<='f')
    inc bl
    inc esi
    jmp @b
  .endif
  .if (al>='0') && (al<='9')
    inc bl
    inc esi
    jmp @b
  .endif
cont:
  cmp bl,0
  jz bad     ;no digits
  mov _str2num_siz_,esi      ; # chars used (including white chars)
  mov eax,s
  sub _str2num_siz_,eax
  dec esi
;go till esi=edi
  xor cl,cl    ;shift #
  xor edx,edx  ;total
@@:
  xor eax,eax
  mov al,[esi]
  .if (al>='A') && (al<='F')
    add al,'a'-'A'
  .endif
  .if (al>='0') && (al<='9')
    sub al,'0'
  .endif
  .if (al>='a') && (al<='f')
    sub al,'a'-10              ;FIX v2.05 Beta #1 : was 'a'+10
  .endif
  shl eax,cl
  add edx,eax
  add cl,4
  dec esi
  cmp esi,edi
  jnz @b
done:
  mov [esp+7*4],edx  ;save EAX for ret
  popad
  ret
str2numx endp

;binary version
str2numb proc,s:dword
  pushad
  mov esi,s
@@:
  mov al,bptr[esi]
  cmp bptr[esi],0
  jz bad
  .if al=='0' || al=='1'
    jmp start
  .endif
  inc esi
  jmp @b
bad:
  popad
  mov _str2num_siz_,0
  xor eax,eax
  ret
start:
  xor ebx,ebx
  mov edi,esi
  dec edi ;go till here
@@:
  cmp bl,32
  ja bad ;to many digits!
  cmp bptr[esi],0
  jz cont
  cmp bptr[esi],'0'
  jb cont
  cmp bptr[esi],'1'
  ja cont
  inc esi
  inc bl
  jmp @b
cont:
  cmp bl,0
  jz bad ;no digits
  mov _str2num_siz_,esi
  mov eax,s
  sub _str2num_siz_,eax
  dec esi
 ;go till esi=edi
  mov ebx,1
  xor ecx,ecx  ;total
@@:
  xor eax,eax
  mov al,[esi]
  sub al,'0'
  mul ebx
  add ecx,eax
  mov eax,2
  mul ebx
  mov ebx,eax
  dec esi
  cmp esi,edi
  jnz @b
done:
  mov [esp+7*4],ecx  ;save eax
  popad
  ret
str2numb endp

;this is atoo???  Octal version
str2numo proc,s:dword
  pushad
  mov esi,s
@@:
  mov al,bptr[esi]
  cmp al,0
  jz bad
  .if (al>='0') && (al<='7')
    jmp start
  .endif
  inc esi
  jmp @b
bad:
  popad
  mov _str2num_siz_,0
  xor eax,eax
  ret
start:
  xor bl,bl
  mov edi,esi
  dec edi
@@:
  cmp bl,8
  ja bad     ;to many digits!
  mov al,[esi]
  cmp bptr[esi],0
  jz cont
  .if (al>='0') && (al<='7')
    inc bl
    inc esi
    jmp @b
  .endif
cont:
  cmp bl,0
  jz bad     ;no digits
  dec esi
  mov _str2num_siz_,esi
  mov eax,s
  sub _str2num_siz_,eax
  inc _str2num_siz_
  ;go till esi=edi
  mov ebx,1
  xor ecx,ecx  ;total
@@:
  xor eax,eax
  mov al,[esi]
  .if (al>='0') && (al<='7')
    sub al,'0'
  .endif
  mul ebx
  add ecx,eax
  mov eax,8
  mul ebx
  mov ebx,eax
  dec esi
  cmp esi,edi
  jnz @b
done:
  mov [esp+7*4],ecx  ;save EAX for ret
  popad
  ret
str2numo endp

strchr proc uses edi ecx,s1:dword,c1:byte
  mov edi,s1
  callp strlen,edi
  mov ecx,eax
  mov al,c1
  repnz scasb
  .if zero?
    dec edi    ;go back to c1
    mov eax,edi
    ret
  .endif
  xor eax,eax  ;else ret NULL
  ret
strchr endp

strcspn proc,s1:dword,s2:dword
  local pos:dword
  pushad
  mov edx,s2
  mov edi,edx
  mov esi,s1
  callp strlen,edi
  mov ebx,eax
  inc ebx  ;must count NULL too
  mov pos,0
@@:
  mov ecx,ebx
  lodsb
  repnz scasb
  .if zero?
    popad
    mov eax,pos
    ret
  .endif
  inc pos
  mov edi,edx
  jmp @b
strcspn endp

strspn proc,s1:dword,s2:dword
  local pos:dword
  pushad
  mov edx,s2
  mov edi,edx
  mov esi,s1
  callp strlen,edi
  mov ebx,eax
  inc ebx  ;must count NULL too
  mov pos,0
@@:
  mov ecx,ebx
  lodsb
  repnz scasb
  .if !zero?
    popad
    mov eax,pos
    ret
  .endif
  inc pos
  mov edi,edx
  jmp @b
strspn endp

strdup proc,s1:dword
  callp strlen,s1
  inc eax  ;for NULL
  callp malloc,eax
  .if eax==NULL
    ret
  .endif
  callp strcpy,eax,s1    ;will return eax
  ret
strdup endp

strlwr proc uses esi edi ecx,s1:dword
  callp strlen,s1
  mov esi,s1
  mov edi,esi
  mov ecx,eax
@@:
  lodsb
  .if (al>='A') && (al<='Z')
    add al,'a'-'A'  ;lower it
    mov [edi],al
  .endif
  inc edi
  dec ecx
  jnz @b
  mov eax,s1
  ret
strlwr endp

strupr proc uses esi edi ecx,s1:dword
  callp strlen,s1
  mov esi,s1
  mov edi,esi
  mov ecx,eax
@@:
  lodsb
  .if (al>='a') && (al<='z')
    add al,'A'-'a'  ;capitilize
    mov [edi],al
  .endif
  inc edi
  dec ecx
  jnz @b
  mov eax,s1
  ret
strupr endp

strpbrk proc,s1:dword,s2:dword
  local pos:dword
  pushad
  mov edi,s2
  mov esi,s1
  callp strlen,edi
  mov ebx,eax
  callp strlen,esi
  mov edx,eax
;  inc ebx  ;DO NOT count NULL
  mov pos,0
@@:
  mov ecx,ebx
  lodsb
  repnz scasb
  .if zero?
    popad
    mov eax,pos
    add eax,s1
    ret
  .endif
  inc pos
  mov edi,s2
  dec edx
  jnz @b
  popad
  xor eax,eax
  ret
strpbrk endp

strrchr proc uses edi ecx,s1:dword,c1:byte
  mov edi,s1
  callp strlen,edi
  mov ecx,eax
  mov al,c1
  std
  repnz scasb
  .if zero?
    inc edi    ;go back to c1
    mov eax,edi
    ret
  .endif
  cld
  xor eax,eax  ;else ret NULL
  ret
strrchr endp

strrev proc,s1:dword
  pushad
  mov esi,s1
  callp strlen,esi
  .if !eax
    popad
    ret
  .endif
  mov edi,s1
  add edi,eax
  mov ecx,eax
  shr ecx,1
@@:
  mov al,[esi]
  mov ah,[edi]
  mov [esi],ah
  mov [edi],al
  inc esi
  dec edi
  dec ecx
  jnz @b
  popad
  mov eax,s1
  ret
strrev endp

strset proc uses edi ecx,s1:dword,c1:byte
  mov edi,s1
  callp strlen,edi
  mov ecx,eax
  mov al,c1
  rep stosb
  mov eax,s1
  ret
strset endp

strstr proc,s1:dword,s2:dword
  pushad
  mov esi,s1
  callp strlen,esi
  mov ecx,eax
  callp strlen,s2
  mov edx,eax
@@:
  callp memcmp,esi,s2,edx
  .if !eax
    mov [esp+7*4],esi
    popad
    ret
  .endif
  inc esi
  dec ecx
  jnz @b
  popad
  xor eax,eax
  ret
strstr endp

strtok proc,s1:dword,s2:dword
  pushad
  mov edi,s1
  cmp edi,NULL
  jz get_next_tok
;find 1st token
  callp strlen,s1
  add eax,s1
  mov tokend,eax
  call find_tok
  mov [esp+7*4],eax
  popad
  ret
get_next_tok:
  mov edi,tok
  .if !edi
    popad
    xor eax,eax
    ret
  .endif
  call find_tok
  mov [esp+7*4],eax
  popad
  ret

find_tok:
  ;edi=string (s1)
  mov esi,s2
  .if !esi    ;s2 should not be NULL
    xor eax,eax
    db 0c3h  ;ret
  .endif
  .if edi > tokend
    xor eax,eax
    mov tok,eax
    db 0c3h  ;ret
  .endif
  callp strlen,esi
  mov ebx,eax
  mov edx,edi
@@:
  callp memcmp,edi,esi,ebx
  .if !eax
    mov ecx,ebx
    mov al,0
    rep stosb
    mov tok,edi  ;tok=next tok area for next time
  .else
    inc edi
    jmp @b
  .endif
@@:
;ret edi
  mov edi,edx
@@:
  .if ! bptr[edi]
    ;gotta move to next thing
    inc edi
    .if edi>tokend
      xor eax,eax
      mov tok,eax
      db 0c3h  ;ret
    .endif
    jmp @b
  .endif
  mov eax,edi
  db 0c3h  ;ret
strtok endp

;have no idea what this is for
;BC help was nohelp in explaining what it even does
;got this from BCv5.0 LIB hacks

strxfrm proc,dest:dword,src:dword,len:dword
  callp strlen,src
  .if eax>=len
    ret    ;return EAX as is
  .endif
  push eax
  inc eax
  callp memcpy,dest,src,eax
  pop eax
  ret
strxfrm endp

stricmp proc,s1:dword,s2:dword
  pushad
  mov esi,s1
  mov edi,s2
@@:
  lodsb
  .if (al>='a') && (al<='z')
    add al,'A'-'a'
  .endif
  mov bl,al
  mov al,[edi]
  inc edi
  .if (al>='a') && (al<='z')
    add al,'A'-'a'
  .endif
  cmp bl,al
  ja above
  jb below
  cmp byte ptr[esi-1],0
  jnz @b
  popad
  xor eax,eax
  ret
above:
  popad
  mov eax,1   ;p1 > p2
  ret
below:
  popad
  or eax,-1    ;p1 < p2
  ret
stricmp endp

gets proc,str1:dword  ;ADDED : v2.01
  pushad              ;FIX : v2.04 Beta #2
@@top:
  mov edi,str1        ; this was using old key codes
@@:                   ; and so was scanf()
  callp _getch
  .if al==KB_ESC   ;ignore this line
    callp putch,'\'
    callp putch,13
    callp putch,10
    jmp @@top
  .endif
  .if al==KB_ENTER
    mov al,0
    stosb
    callp putch,10  ;print a \n
    callp putch,13
    popad
    mov eax,str1
    ret
  .endif
  .if ((al==KB_BS) || (ax==KB_LEFT)) && (edi!=str1)
    callp putch,8
    callp putch,' '
    callp putch,8
    dec edi
    jmp @b
  .endif
  .if (al<32)  ;don't allow certain codes
    jmp @b
  .endif
  stosb
  callp putch,al
  jmp @b
gets endp

puts proc,str1:dword  ;ADDED : v2.01
  callp print,str1
  callp putch,10
  callp putch,13
  xor eax,eax
  ret
puts endp

end